Data operations on processors may be performed with the use of registers, data buses and memory arrays. Most processors may have one or more registers called accumulators. An accumulator register may be where the arithmetic and logic operations are performed for the processor. Data may be taken from memory in the processor and stored into the accumulator register. Operations may be performed with the contents of the accumulator, such as ADD and SUBTRACT commands. After these operations, the results may be stored in the accumulator. The contents of the memory register remain unchanged.
In many controlled algorithms, such as state estimators and Kalman filters, accumulative results in the accumulator register may exceed the range of the register, resulting in register overflow. For example, a 32-bit accumulator register may have a result that exceeds the most positive or the most negative value of the 32-bit register. To accommodate these overflows, the register may be extended beyond its current bit size to extend its dynamic range. However, instructions and code written for the original bit size of the accumulator register would not be compatible with this new dynamic range. The same numerical operations are not maintained, and the effects on the carry and overflow flags for the register are different in the extended case. Floating point operations may be implemented instead of physically extending the range of the register, but these operations also require more instructions and software code. Further, the above solutions all require more silicon and higher costs to implement on a processor.